home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1998 July / EnigmA AMIGA RUN 29 (1998)(G.R. Edizioni)(IT)[!][issue 1998-07 & 08].iso / earcd / grafica / ghostscript / 5.10 / pdf_base.ps < prev    next >
Text File  |  1997-12-28  |  15KB  |  457 lines
  1. %    Copyright (C) 1994, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % pdf_base.ps
  19. % Basic parser for PDF reader.
  20.  
  21. % This handles basic parsing of the file (including the trailer
  22. % and cross-reference table), as well as objects, object references,
  23. % and streams; it doesn't include any facilities for making marks on
  24. % the page.
  25.  
  26. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  27. .currentglobal true .setglobal
  28. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  29. pdfdict begin
  30.  
  31. % We rebind #, #?, #dsc, and #dscfile later if we're writing out PostScript.
  32. /#            % <arg1> ... <argN> <opname> <N> # -
  33.  { pop cvx exec
  34.  } bind def
  35. /#?
  36.  { false
  37.  } bind def
  38. /#dsc            % mark <obj1> ... #dsc -
  39.  { cleartomark
  40.  } bind def
  41. /#dscfile        % <filename> #dscfile -
  42.  { pop
  43.  } bind def
  44.  
  45. % Define the name interpretation dictionary for reading values.
  46. /valueopdict mark
  47.   (<<) cvn { mark } bind    % don't push an actual mark!
  48.   (>>) cvn /.dicttomark load
  49.   ([) cvn { mark } bind        % ditto
  50.   (]) cvn dup load
  51.   /true true
  52.   /false false
  53.   /null null
  54.   /F dup cvx        % see Objects section below
  55.   /R dup cvx        % see Objects section below
  56.   /stream dup cvx    % see Streams section below
  57. .dicttomark readonly def
  58.  
  59. % ------ Utilities ------ %
  60.  
  61. % Define a scratch string.  The PDF language definition says that
  62. % no line in a PDF file can exceed 255 characters.
  63. /pdfstring 255 string def
  64.  
  65. % Read the previous line of a file.  If we aren't at a line boundary,
  66. % read the line containing the current position.
  67. % Skip any blank lines.
  68. /prevline        % - prevline <startpos> <substring>
  69.  { PDFfile fileposition dup () pdfstring
  70.    2 index 257 sub 0 .max PDFfile exch setfileposition
  71.     {        % Stack: initpos linepos line string
  72.       PDFfile fileposition
  73.       PDFfile 2 index readline pop
  74.       dup length 0 gt
  75.        { 3 2 roll 5 -2 roll pop pop 2 index }
  76.        { pop }
  77.       ifelse
  78.         % Stack: initpos linepos line string startpos
  79.       PDFfile fileposition 5 index ge { exit } if
  80.       pop
  81.     }
  82.    loop pop pop 3 -1 roll pop
  83.  } bind def
  84.  
  85. % Read a token from a file, recognizing the PDF 1.2 #nn escape convention.
  86. % This should be done in C!
  87. /.pdftoken            % <file> .pdftoken <obj> -true-
  88.                 % <file> .pdftoken -false-
  89. { token
  90.    { dup type /nametype eq
  91.       { dup xcheck
  92.      { true
  93.      }
  94.      { dup .namestring (#) search
  95.         { name#escape cvn exch pop }
  96.         { pop }
  97.        ifelse true
  98.      }
  99.     ifelse
  100.       }
  101.       { true
  102.       }
  103.      ifelse
  104.    }
  105.    { false
  106.    }
  107.   ifelse
  108. } bind def
  109. /name#escape            % <post> <(#)> <pre> name#escape <string>
  110. { exch pop
  111.   1 index 2 () /SubFileDecode filter dup (x) readhexstring
  112.         % Stack: post pre stream char t/f
  113.   not { /.pdftoken cvx /syntaxerror signalerror } if
  114.   exch closefile concatstrings
  115.   exch 2 1 index length 2 sub getinterval
  116.   (#) search { name#escape } if concatstrings
  117. } bind def
  118.  
  119. % Execute a file, interpreting its executable names in a given
  120. % dictionary.  The name procedures may do whatever they want
  121. % to the operand stack.
  122. /.pdfrun            % <file> <opdict> .pdfrun -
  123.  {    % Construct a procedure with the stack depth, file and opdict
  124.     % bound into it.
  125.    1 index cvlit count 2 sub 3 1 roll mark mark 5 2 roll
  126.     {    % Stack: ..operands.. count opdict file
  127.       .pdftoken not { (%%EOF) cvn cvx } if
  128.       dup xcheck
  129.        { DEBUG { dup == flush } if
  130.      2 copy .knownget
  131.       { exch pop exch pop exch pop exec }
  132.       { BXlevel 0 le
  133.          { (%stderr) (w) file
  134.            dup (****************Unknown operator: ) writestring
  135.            dup 2 index .writecvs dup (\n) writestring flushfile
  136.          }
  137.         if pop pop
  138.         count exch sub { pop } repeat    % pop all the operands
  139.       }
  140.      ifelse
  141.        }
  142.        { exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  143.        }
  144.       ifelse
  145.     }
  146.    aload pop .packtomark cvx
  147.    /loop cvx 2 packedarray cvx
  148.     { stopped /PDFsource } aload pop
  149.    PDFsource
  150.     { store { stop } if } aload pop .packtomark cvx
  151.    /PDFsource 3 -1 roll store exec
  152.  } bind def
  153.  
  154. % ------ File reading ------ %
  155.  
  156. % Read the cross-reference entry for an (unresolved) object.
  157. % The caller must save and restore the PDFfile position if desired.
  158. % For invalid (free) objects, we return 0.
  159. /readxrefentry        % <object#> readxrefentry <objpos>
  160.  { dup Objects exch lget
  161.    PDFfile exch setfileposition
  162.    PDFfile token pop        % object position
  163.    PDFfile token pop        % generation #
  164.    PDFfile token pop        % n or f
  165.    dup /n eq
  166.     { pop 1 add dup 255 gt
  167.        { Generations ltype /stringtype eq
  168.       {        % Convert Generations from a string to an array.
  169.         larray Generations llength lgrowto dup
  170.         0 1 2 index llength 1 sub
  171.          { Generations 1 index lget lput dup
  172.          }
  173.         for pop /Generations exch store
  174.       }
  175.      if
  176.        }
  177.       if
  178.     }
  179.     { /f eq
  180.        { pop 0 }
  181.        { /readxrefentry cvx /syntaxerror signalerror }
  182.       ifelse
  183.     }
  184.    ifelse
  185.         % Stack: obj# objpos 1+gen#
  186.    Generations 4 -1 roll 3 -1 roll lput
  187.  } bind def
  188.  
  189. % ================================ Objects ================================ %
  190.  
  191. % Since we may have more than 64K objects, we have to use a 2-D array to
  192. % hold them (and the parallel Generations structure).
  193. /lshift 9 def
  194. /lnshift lshift neg def
  195. /lsubmask 1 lshift bitshift 1 sub def
  196. /lsublen lsubmask 1 add def
  197. /larray {    % - larray <larray>
  198.   [ [] ]
  199. } bind def
  200. /lstring {    % - lstring <lstring>
  201.   [ () ]
  202. } bind def
  203. /ltype {    % <lseq> type <type
  204.   0 get type
  205. } bind def
  206. /lget {        % <lseq> <index> lget <value>
  207.   dup //lsubmask and 3 1 roll //lnshift bitshift get exch get
  208. } bind def
  209. /lput {        % <lseq> <index> <value> lput -
  210.   3 1 roll
  211.   dup //lsubmask and 4 1 roll //lnshift bitshift get
  212.   3 1 roll put
  213. } bind def
  214. /llength {    % <lseq> llength <length>
  215.   dup length 1 sub dup //lshift bitshift
  216.   3 1 roll get length add
  217. } bind def
  218. % lgrowto assumes newlength > llength(lseq)
  219. /growto {    % <string/array> <length> growto <string'/array'>
  220.   1 index type /stringtype eq { string } { array } ifelse
  221.   2 copy copy pop exch pop
  222. } bind def
  223. /lgrowto {    % <lseq> <newlength> lgrowto <lseq'>
  224.     dup //lsubmask add //lnshift bitshift dup 3 index length gt {
  225.     % Add more sub-arrays.  Start by completing the last existing one.
  226.         % Stack: lseq newlen newtoplen
  227.     3 -1 roll dup llength 1 sub //lsubmask or 1 add lgrowto
  228.         % Stack: newlen newtoplen lseq
  229.     [ exch aload pop
  230.     counttomark 2 add -1 roll        % newtoplen
  231.     counttomark sub { dup 0 0 getinterval lsublen growto } repeat
  232.     dup 0 0 getinterval ] exch
  233.   } {
  234.     pop
  235.   } ifelse
  236.     % Expand the last sub-array.
  237.   1 sub //lsubmask and 1 add
  238.   exch dup dup length 1 sub 2 copy
  239.         % Stack: newsublen lseq lseq len-1 lseq len-1
  240.   get 5 -1 roll growto put
  241. } bind def
  242.  
  243. % We represent an unresolved object reference by a procedure of the form
  244. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  245. % no way to represent procedures.  Since PDF in fact has no way to represent
  246. % any PostScript object that doesn't evaluate to itself, we can 'force'
  247. % a possibly indirect object painlessly with 'exec'.
  248. % Note that since we represent streams by executable dictionaries
  249. % (see below), we need both an xcheck and a type check to determine
  250. % whether an object has been resolved.
  251. /unresolved?        % <object#> unresolved? <bool>
  252.  { Objects exch lget dup xcheck exch type /integertype eq and
  253.  } bind def
  254. /oforce /exec load def
  255. /oget        % <array> <index> oget <object>
  256.         % <dict> <key> oget <object>
  257.  { 2 copy get dup xcheck
  258.     { exec dup 4 1 roll put }
  259.     { exch pop exch pop }
  260.    ifelse
  261.  } bind def
  262. % A null value in a dictionary is equivalent to an omitted key;
  263. % we must check for this specially.
  264. /knownoget
  265.  { 2 copy known
  266.     { oget dup null eq { pop false } { true } ifelse }
  267.     { pop pop false }
  268.    ifelse
  269.  } bind def
  270.  
  271. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  272. % Per the specification, we convert these to nulls.
  273. /F        % <file#> <object#> <generation#> F <object>
  274.  {        % Some PDF 1.1 files use F as a synonym for f!
  275.    count 3 lt { f } { pop pop pop null } ifelse
  276.  } bind def
  277.  
  278. % We keep track of objects in a pair of arrays, Objects and Generations.
  279. % Generations[N] is 1+ the current generation number for object number N.
  280. % (As far as we can tell, this is needed only for error checking.)
  281. % If object N is loaded, Objects[N] is the actual object;
  282. % otherwise, Objects[N] is an executable integer giving the file offset
  283. % of the object's entry in the cross-reference table.
  284. % For free objects, Generations[N] is 0.
  285. /checkgeneration  % <object#> <generation#> checkgeneration <object#> <OK>
  286.  { Generations 2 index lget 1 sub 1 index eq
  287.     { pop true
  288.     }
  289.     { (Warning: wrong generation: ) print 1 index =only ( ) print = false
  290.     }
  291.    ifelse
  292.  } bind def
  293. /R        % <object#> <generation#> R <object>
  294.  { 1 index unresolved?
  295.     { /resolveR cvx 3 packedarray cvx }
  296.     { checkgeneration { Objects exch lget } { pop null } ifelse }
  297.    ifelse
  298.  } bind def
  299.  
  300. % If we encounter an object definition while reading sequentially,
  301. % we just store it away and keep going.
  302. /objopdict mark
  303.   valueopdict { } forall
  304.   /endobj dup cvx
  305. .dicttomark readonly def
  306. /obj            % <object#> <generation#> obj <object>
  307.  { PDFfile objopdict .pdfrun
  308.  } bind def
  309. /endobj            % <object#> <generation#> <object> endobj <object>
  310.  { 3 1 roll
  311.         % Read the xref entry if we haven't yet done so.
  312.         % This is only needed for generation # checking.
  313.    1 index unresolved?
  314.     { PDFfile fileposition
  315.       2 index readxrefentry pop
  316.       PDFoffset add PDFfile exch setfileposition
  317.     } if
  318.    checkgeneration { Objects exch 2 index lput } { pop pop null } ifelse
  319.  } bind def
  320.  
  321. % When resolving an object reference, we stop at the endobj.
  322. /resolveopdict mark
  323.   valueopdict { } forall
  324.   /endobj { endobj exit } bind
  325. .dicttomark readonly def
  326. /resolveR        % <object#> <generation#> resolveR <object>
  327.  { DEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  328.    1 index unresolved?
  329.     { PDFfile fileposition 3 1 roll
  330.       1 index readxrefentry
  331.       3 1 roll checkgeneration
  332.        {        % Stack: savepos objpos obj#
  333.      exch PDFoffset add PDFfile exch setfileposition
  334.      PDFfile token pop 2 copy ne
  335.       { (xref error!\n) print /resolveR cvx /rangecheck signalerror
  336.       }
  337.      if pop PDFfile token pop
  338.      PDFfile token pop /obj ne
  339.       { (xref error!\n) print /resolveR cvx /rangecheck signalerror
  340.       }
  341.      if
  342.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  343.        }
  344.        { Objects exch null lput pop null
  345.        }
  346.       ifelse exch PDFfile exch setfileposition
  347.     }
  348.     { pop Objects exch lget
  349.     }
  350.    ifelse
  351.  } bind def      
  352.  
  353. %================================ Streams ================================ %
  354.  
  355. % We represent a stream by an executable dictionary that contains,
  356. % in addition to the contents of the original stream dictionary:
  357. %    /File - the file or string where the stream contents are stored;
  358. %    /FilePosition - iff File is a file, the position in the file
  359. %      where the contents start.
  360. %    /StreamKey - the key used to decrypt this stream if any
  361. % We do the real work of constructing the data stream only when the
  362. % contents are needed.
  363.  
  364. % Construct a stream.  The length is not reliable in the face of
  365. % different end-of-line conventions, but it's all we've got.
  366. %
  367. % PDF files are inconsistent about what may fall between the 'stream' keyword
  368. % and the actual stream data, and it appears that no one algorithm can
  369. % detect this reliably.  We used to try to guess whether the file included
  370. % extraneous \r and/or \n characters, but we no longer attempt to do so,
  371. % especially since the PDF 1.2 specification states flatly that the only
  372. % legal terminators following the 'stream' keyword are \n or \r\n, both of
  373. % which are properly skipped and discarded by the token operator.
  374. /stream
  375.  { PDFsource PDFfile eq
  376.     { dup /File PDFfile put
  377.       dup /FilePosition PDFfile fileposition put
  378.       DEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  379.       PDFfile fileposition 1 index /Length oget add
  380.         PDFfile exch setfileposition
  381.     }
  382.     {    % We're already reading from a stream, which we can't reposition.
  383.     % Capture the sub-stream contents in a string.
  384.       dup /Length oget string PDFsource exch readstring
  385.       not
  386.        { (Unexpected EOF in stream!\n) print
  387.      /stream cvx /rangecheck signalerror
  388.        }
  389.       if
  390.       1 index exch /File exch put
  391.     }
  392.    ifelse
  393.    PDFsource token pop
  394.      /endstream ne { /stream cvx /syntaxerror signalerror } if
  395.    cvx
  396.  } bind def
  397.  
  398. % Resolve a stream dictionary to a PostScript stream.
  399. % Streams with no filters require special handling:
  400. %    - If we are going to interpret their contents, we let endstream
  401. %      terminate the interpretation loop;
  402. %    - If we are just going to read data from them, we impose
  403. %      a SubFileDecode filter that reads just the requisite amount of data.
  404. % Note that, in general, resolving a stream repositions PDFfile.
  405. % Clients must save and restore the position of PDFfile themselves.
  406. /resolvestream        % <streamdict> <readdata?> resolvestream <stream>
  407.  { exch dup /FilePosition .knownget
  408.     { 1 index /File get exch setfileposition }
  409.    if
  410.         % Stack: readdata? dict
  411.    dup /DecodeParms .knownget not { null } if
  412.    1 index /Filter .knownget not { {} } if
  413.    dup type /nametype eq
  414.     { 1 array astore
  415.       1 index null ne { exch 1 array astore exch } if
  416.     }
  417.    if
  418.         % Stack: readdata? dict parms filternames
  419.    2 index /File get exch
  420.         % Stack: readdata? dict parms file/string filternames
  421.    pdf_decrypt_stream        % add decryption if needed
  422.    dup length 0 eq
  423.     {        % All the PDF filters have EOD markers, but in this case
  424.         % there is no specified filter.
  425.       pop exch pop
  426.         % Stack: readdata? dict file/string
  427.       2 index
  428.        {    % We're going to read data; use a SubFileDecode filter.
  429.      1 index /Length oget () /SubFileDecode filter
  430.        }
  431.        { dup type /filetype ne
  432.       {    % Use a SubFileDecode filter to read from a string.
  433.         0 () SubFileDecode filter
  434.       }
  435.      if
  436.        }
  437.       ifelse
  438.     }
  439.     { 2 index null eq
  440.        { { filter }
  441.        }
  442.        {    % Stack: readdata? dict parms file/string filtername
  443.          { 2 index 0 get dup null eq { pop } { exch } ifelse filter
  444.        exch dup length 1 sub 1 exch getinterval exch
  445.      }
  446.        }
  447.       ifelse forall exch pop
  448.     }
  449.    ifelse
  450.         % Stack: readdata? dict file
  451.    exch pop exch pop
  452.  } bind def
  453. /endstream { exit } def
  454.  
  455. end            % pdfdict
  456. .setglobal
  457.